package com.bart.a_data_type

/*

1. scala集合：
  - 可变集合：scala.collection.mutable
  - 不可变集合：scala.collection.immutable
优先采用不可变集合
所有的几个都扩展了Iterable

2. 集合分类
  - 序列: List
  - 集合: Set
  - 映射: Map
----------------------------------
              数组
----------------------------------
1. 不可变数组：
val arr = new Array[Int](10)
arr(0)=10

# 多维数组
val arr = new Array[Int](10,10)

2. 可变数组（必须先导包 import scala.collection.mutable.ArrayBuffer ）
val arr = ArrayBuffer[Int]()
arr.append(0)
arr(0)
# 需要注意的是使用可变数组的时候，取值的时候的下表必须存在，例如：如果
# 此时arr中只有一个元素arr(0)是正确的，但是arr(1)就会报错，因为时候索引
# 为1的位置并没有值，和java的ArrayList不一样scala不会默认初始化大小

3. 互相转换
# Array -> ArrayBuffer
val a3 = arrs.toBuffer

# ArrayBuffer -> Array
val a3 = arrs.toArray
》》》注意：数组转换不会影响原来的数组而是会产生新的数组

4. Java 和 Scala 的数组互转
import scala.collection.JavaConverters._
import scala.collection.mutable.ArrayBuffer
val command = ArrayBuffer("ls","-al","/")

// command.asJava 其中的 asScala 是一个数组的方法
val jc = new ProcessBuilder(command.asJava)

// 转化后的java类型的对象jc中的 asScala 方法
val sc = jc.command().asScala
----------------------------------
1. map
val arr = Array[Int] = Array(1, 2, 3, 4, 5)

scala> arr.map((x:Int) => x*10)
res17: Array[Int] = Array(10, 20, 30, 40, 50)

scala> arr.map(x => x*10)
res18: Array[Int] = Array(10, 20, 30, 40, 50)

scala> arr.map(_*10)
res20: Array[Int] = Array(10, 20, 30, 40, 50)

2. flatten 和 flatMap（多维专转化为一维）
val arr = Array("hello world","this is nice day")

scala> arr.map(_.split(" "))
res29: Array[Array[String]] = Array(Array(hello, world), Array(this, is, nice, day))

scala> arr.map(_.split(" ")).flatten
res32: Array[String] = Array(hello, world, this, is, nice, day)


scala> arr.flatMap(_.split(" "))
res32: Array[String] = Array(hello, world, this, is, nice, day)

3. filter
scala> val arr = Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

scala> arr.filter(_ % 2 ==0)
res36: Array[Int] = Array(2, 4)

4. reduce
把集合中的元素收集起来

scala> val arr = Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

scala> arr.reduce(_+_)
res39: Int = 15

5. foreach
scala> arr
res40: Array[Int] = Array(1, 2, 3, 4, 5)

scala> arr.foreach(println)
1
2
3
4
5

6. groupBy
scala> val arr = Array("hello world","hello new world")
arr: Array[String] = Array(hello world, hello new world)

scala> arr.flatMap(_.split(" ")).groupBy(x=>x).map(x => x._2)
res48: scala.collection.immutable.Iterable[Array[String]] = List(Array(world, world), Array(new), Array(hello, hello))

7. mapValues
scala> arr.flatMap(_.split(" ")).groupBy(x=>x).mapValues(_.length)
res50: scala.collection.immutable.Map[String,Int] = Map(world -> 2, new -> 1, hello -> 2)

8. toList 和 sortBy
scala> arr.flatMap(_.split(" ")).groupBy(x=>x).mapValues(_.length).toList.sortBy(x => x._2)
res51: List[(String, Int)] = List((new,1), (world,2), (hello,2))

scala> arr.flatMap(_.split(" ")).groupBy(x=>x).mapValues(_.length).toList.sortBy(x => -x._2)
res52: List[(String, Int)] = List((world,2), (hello,2), (new,1))



----------------------------------
              映射
----------------------------------
1. 不可变映射
val scores = Map("Alice" -> 10,"Bob" -> 20,"Cindy" -> 30)

2. 可变映射
val scores = scala.collection.mutable.Map("Alice" -> 10,"Bob" -> 20,"Cindy" -> 30)

3. 空映射
val sores = new scala.collection.mutable.HashMap[String,Int]

4. 不可变的元组Map映射
val sc = Map(("a" -> 1),("b" -> 2))

5. 修改可变集合的内容
// 添加 key 为 a value 为 1
scores("a")=1
// 删除 key 为 a 的元素
scores-="a"
// 添加两个元素
scores+=("a" -> 1, "b" -> 2)

----------------------------------
              元组
----------------------------------
1. 赋值
val tuple = (1,"a",12.7860)
2. 访问（xxx._索引，注意元组的索引是从1开始的）
scala> tuple._1
res41: Int = 1

scala> tuple._2
res42: String = a

scala> tuple._3
res43: Double = 12.786

3. 不可变的 Array 使用 zip(xxx) 可以将两个array每个相同索引下面的下标
   组合成一个元组的array，多余的索引会被舍弃
scala> val a1 = Array(1,2,3)
a1: Array[Int] = Array(1, 2, 3)

scala> val a2 = Array("a","b","c","d")
a2: Array[String] = Array(a, b, c, d)

scala> a1.zip(a2)
res44: Array[(Int, String)] = Array((1,a), (2,b), (3,c))

----------------------------------
              队列
----------------------------------
1. 创建队列
val q1 = new scala.collection.mutable.Queue[Int]

2. 添加一个值
q1+=1

3. 添加多个值（集合）
q1 ++= List(2,3,4)

4. 出列1个
q1.dequeue()

5. 入列多个
q1.enequeue(5,6,7)

6. 队列头元素
q1.head()

7. 队列尾元素
q1.tail

----------------------------------
             堆栈
----------------------------------
1. 创建
import scala.collection.mutable.Stack
val stack1 = Stack[Int]()

2. 入栈
stack1.push(1)

3. 出栈
stack1.pop()

4. 查看下一个元素
stack1.top

5. 清空
stack1.clear

----------------------------------
             列表
----------------------------------
列表为空使用Nil表示
1. 创建
val list = List(1,2,3)
2. 添加
左追加
9::list

右追加
list.::(9)

3. 删除

4. 清空



// 实在是太多了，具体参照官方文档吧。。。








*/
class _03_DataStructure {

}
